java

java 101

Posted by ZhengYang on 2016-09-11

1 java命名习惯

包名一律小写：xxxyyyzzz
类名、接口名应当使用名词，每个单词的首字母大写：XxxYyyZzz
方法，变量第一个单词小写，后面每个单词的首字母大写：xxxYyyZzz
常量名中的每个字母一律大写：XXXYYYZZZ

2 类的访问控制

class只能被public、default、abstract、final修饰。
当我们import一个包的所有的类，并不会import这个包中的子包中的类
如果需要用到子包的类，需要再次对子包单独引入

3 类成员的访问控制

private default protected public
同一类 √ √ √ √
同一包中的类 √ √ √
子类 √ √
其他包中的类 √

包中的类不能同名，不论public与否

4 final

final 可以声明类，属性，方法

  • 类不能被继承
  • 属性为常量
  • 方法不能被子类继承

5 变量类型

  • 基本类型
    • 数值型
      • 整数类型 （byte，short，int，long）
      • 浮点型 （float，double）
    • 字符型 （char）
    • 布尔型 （boolean）
  • 引用类型
    • 数组
    • 类 （class）
    • 接口 （interface）

类成员变量会初始化，但局部变量不会初始化，所以在引用前必须初始化（不论是引用类型，还是基本类型）。

6 参数传递

  • 基本类型是传值，不会改变实参的值，只能通过返回得到结果。
  • 引用类型是传引用，会改变实参的值，不通过返回也可得到结果。

7 优先级

运算符 结合优先级（其余都是从左向右）
. [] () {} ; ,
++ – ~ ! 从右向左
+ -
<< >> >>>
< ><= >=
== !=
&
^
|
&&
||
?:
=

8 数组初始化

数组在定义时，就必须指定长度， 如果不确定长度，可以使用ArrayList

1
2
3
4
5
6
7
8
9
10
11
int[] a = {1,2,3};
int[] b = new int[5];
int[] c = new int[]{1,2,3};
int[] d = a.clone();
Arrays.sort(d);
import java.util.*;
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5);
list.get(0);

9 内部类

在类中直接定义的内部类，仅限这个类的内部使用。
内部类对象保存了一个外部类对象的引用，当内部类访问的变量或方法不存在时，会通过这个引用去访问外部类的变量或方法。
一个内部类可以访问它的外部类的成员，但反过来就不行。即内部类的成员只有在内部类的范围内使用，不能被外部类使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Outer{
    int outer_i = 100;
    void test(){
        Inner in = new Inner();
        in.display();
    }
    class Inner{
        void display(){
            System.out.println("display: outer_i = " + outer_i++);
        }
    }
}
public class InnerClassDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test();
    }
}
//// 输出
// display: outer_i = 100

9.1 内部类 如何被外部引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Outer{
    int outer_i = 100;
    void test(){
        Inner in = new Inner();
        in.display();
    }
    class Inner{
        void display(){
            System.out.println("display: outer_i = "+ outer_i++);
        }
    }
}
public class InnerClassDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test();
    // 外部类.内部类 inner1 = 外部类对象.new 内部类()
        Outer.Inner inner1 = outer.new Inner();  
        inner1.display();
    // 外部类.内部类 inner1 = new 外部类().new 内部类()
        Outer.Inner inner2 = new Outer().new Inner();
        inner2.display();
    }
}
//// 输出
// display: outer_i = 100
// display: outer_i = 101
// display: outer_i = 100

9.2 匿名内部类

定义了一个类A的子类，并且直接new了一个子类的实例。
匿名内部类 用于抽象类的 继承+new
匿名内部类 用于接口的 实现+new

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
abstract class A{
    abstract public void fun();
}
public class Outer {
    public void callInner(A a){
        a.fun();
    }
    public static void main(String[] args) {
        Outer outer = new Outer();
    // 匿名内部类 用于抽象类的 继承+new
    A a = new A(){
            public void fun(){
                System.out.println("implement fun");
            }
        };
        outer.callInner(a);
    }
}
//// 输出
// implement fun
//// 输出
// implement fun

10 泛型

  • 泛型类
    是在实例化类的时候指明泛型的具体类型
    Test\ t = new Test\();
  • 泛型方法
    是在调用方法的时候指明泛型的具体类型。
1
2
3
4
5
6
7
8
9
// 泛型类
public class Test<T>{}
// 泛型方法
public static <T> void fun1(T t){}
public static <T> T fun2(T t){
    return t;
}

Reference

http://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html